#include "../arbol/ArbolBMas.h"
#include "../arbol/RegDatos.h"
#include "../arbol/RegIndice.h"
#include "../arbol/NodoDatos.h"
#include "../arbol/NodoIndice.h"
#include "../arbol/ArchivoBloques.h"
#include "../arbol/ClaveString.h"
#include "../arbol/ClaveInt.h"
#include "../arbol/Clave3Int.h"
#include "../arbol/DatoInt.h"
#include "../arbol/DatoString.h"
#include "../arbol/Dato2Int.h"
#include "ArbolTest.h"
#include "testTools.h" 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <list>
#include <iostream>

using namespace std;

void pruebaRecuperarDatos2Int3(){

	ArbolBMas<ClaveString,Dato2Int>* a = new ArbolBMas<ClaveString,Dato2Int>("datoscomp.bin",100,false);

	ClaveString* clave = new ClaveString();
	(*clave).setClave("P");	
	
	RegDatos<ClaveString,Dato2Int>* reg1 = (*a).buscar(clave);

	list<Dato2Int*> datos = (*reg1).getDatos();

	for (list<Dato2Int*> :: iterator it = datos.begin(); it!=datos.end(); ++it){

		cout << (*((Dato2Int*)(*it))) << endl;

	}

	delete clave;
	delete reg1;
	delete a;
}

void pruebaRecuperarDatos2Int2(){

	ArbolBMas<ClaveString,Dato2Int>* a = new ArbolBMas<ClaveString,Dato2Int>("datoscomp.bin",100,false);

	ClaveString* clave = new ClaveString();
	(*clave).setClave("D");	
	
	RegDatos<ClaveString,Dato2Int>* reg1 = (*a).buscar(clave);

	list<Dato2Int*> datos = (*reg1).getDatos();

	for (list<Dato2Int*> :: iterator it = datos.begin(); it!=datos.end(); ++it){

		cout << (*((Dato2Int*)(*it))) << endl;

	}

	delete clave;
	delete reg1;
	delete a;
}

void pruebaRecuperarDatos2Int1(){

	ArbolBMas<ClaveString,Dato2Int>* a = new ArbolBMas<ClaveString,Dato2Int>("datoscomp.bin",100,false);

	ClaveString* clave = new ClaveString();
	(*clave).setClave("I");	
	
	RegDatos<ClaveString,Dato2Int>* reg1 = (*a).buscar(clave);

	list<Dato2Int*> datos = (*reg1).getDatos();

	for (list<Dato2Int*> :: iterator it = datos.begin(); it!=datos.end(); ++it){

		cout << (*((Dato2Int*)(*it))) << endl;

	}

	delete clave;
	delete reg1;
	delete a;
}

void pruebaInsertarConDato2Int1(){

	ArbolBMas<ClaveString,Dato2Int>* a = new ArbolBMas<ClaveString,Dato2Int>("datoscomp.bin",100,true);

	// INSERTAR UN NUEVO REGISTRO 1

	ClaveString* nueva1 = new ClaveString();
	(*nueva1).setClave("G");
	
	Dato2Int* nDato1 = new Dato2Int();
	(*nDato1).setDato1(25);
	(*nDato1).setDato2(10);
	
	RegDatos<ClaveString,Dato2Int>* nuevo1 = new RegDatos<ClaveString, Dato2Int>();
	(*nuevo1).setClave(nueva1);
	(*nuevo1).cargarDato(nDato1);
	
	int ins1 = (*a).insertarRegistro(nuevo1);
	
	cout << ins1 << endl;

	// INSERTAR UN NUEVO REGISTRO 2

	ClaveString* nueva2 = new ClaveString();
	(*nueva2).setClave("H");
	
	Dato2Int* nDato2 = new Dato2Int();
	(*nDato2).setDato1(25);
	(*nDato2).setDato2(10);
	
	RegDatos<ClaveString,Dato2Int>* nuevo2 = new RegDatos<ClaveString, Dato2Int>();
	(*nuevo2).setClave(nueva2);
	(*nuevo2).cargarDato(nDato2);
	
	int ins2 = (*a).insertarRegistro(nuevo2);
	
	cout << ins2 << endl;
	
	// INSERTAR UN NUEVO REGISTRO 3

	ClaveString* nueva3 = new ClaveString();
	(*nueva3).setClave("I");
	
	Dato2Int* nDato3 = new Dato2Int();
	(*nDato3).setDato1(25);
	(*nDato3).setDato2(10);
	
	RegDatos<ClaveString,Dato2Int>* nuevo3 = new RegDatos<ClaveString, Dato2Int>();
	(*nuevo3).setClave(nueva3);
	(*nuevo3).cargarDato(nDato3);
	
	int ins3 = (*a).insertarRegistro(nuevo3);
	
	cout << ins3 << endl;
	
	// INSERTAR UN NUEVO REGISTRO 4

	ClaveString* nueva4 = new ClaveString();
	(*nueva4).setClave("J");
	
	Dato2Int* nDato4 = new Dato2Int();
	(*nDato4).setDato1(25);
	(*nDato4).setDato2(10);
	
	RegDatos<ClaveString,Dato2Int>* nuevo4 = new RegDatos<ClaveString, Dato2Int>();
	(*nuevo4).setClave(nueva4);
	(*nuevo4).cargarDato(nDato4);
	
	int ins4 = (*a).insertarRegistro(nuevo4);
	
	cout << ins4 << endl;
	
	// INSERTAR UN NUEVO REGISTRO 5

	ClaveString* nueva5 = new ClaveString();
	(*nueva5).setClave("K");
	
	Dato2Int* nDato5 = new Dato2Int();
	(*nDato5).setDato1(25);
	(*nDato5).setDato2(10);
	
	RegDatos<ClaveString,Dato2Int>* nuevo5 = new RegDatos<ClaveString, Dato2Int>();
	(*nuevo5).setClave(nueva5);
	(*nuevo5).cargarDato(nDato5);
	
	int ins5 = (*a).insertarRegistro(nuevo5);
	
	cout << ins5 << endl;			


	delete a;		

}


void pruebaInsertarConDato2Int2(){

	ArbolBMas<ClaveString,Dato2Int>* a = new ArbolBMas<ClaveString,Dato2Int>("datoscomp.bin",100,false);

	// INSERTAR UN NUEVO REGISTRO 1

	ClaveString* nueva1 = new ClaveString();
	(*nueva1).setClave("A");
	
	Dato2Int* nDato1 = new Dato2Int();
	(*nDato1).setDato1(25);
	(*nDato1).setDato2(10);
	
	RegDatos<ClaveString,Dato2Int>* nuevo1 = new RegDatos<ClaveString, Dato2Int>();
	(*nuevo1).setClave(nueva1);
	(*nuevo1).cargarDato(nDato1);
	
	int ins1 = (*a).insertarRegistro(nuevo1);
	
	cout << ins1 << endl;

	// INSERTAR UN NUEVO REGISTRO 2

	ClaveString* nueva2 = new ClaveString();
	(*nueva2).setClave("C");
	
	Dato2Int* nDato2 = new Dato2Int();
	(*nDato2).setDato1(25);
	(*nDato2).setDato2(10);
	
	RegDatos<ClaveString,Dato2Int>* nuevo2 = new RegDatos<ClaveString, Dato2Int>();
	(*nuevo2).setClave(nueva2);
	(*nuevo2).cargarDato(nDato2);
	
	int ins2 = (*a).insertarRegistro(nuevo2);
	
	cout << ins2 << endl;
	
	// INSERTAR UN NUEVO REGISTRO 3

	ClaveString* nueva3 = new ClaveString();
	(*nueva3).setClave("D");
	
	Dato2Int* nDato3 = new Dato2Int();
	(*nDato3).setDato1(25);
	(*nDato3).setDato2(10);
	
	RegDatos<ClaveString,Dato2Int>* nuevo3 = new RegDatos<ClaveString, Dato2Int>();
	(*nuevo3).setClave(nueva3);
	(*nuevo3).cargarDato(nDato3);
	
	int ins3 = (*a).insertarRegistro(nuevo3);
	
	cout << ins3 << endl;
	
	// INSERTAR UN NUEVO REGISTRO 4

	ClaveString* nueva4 = new ClaveString();
	(*nueva4).setClave("B");
	
	Dato2Int* nDato4 = new Dato2Int();
	(*nDato4).setDato1(25);
	(*nDato4).setDato2(10);
	
	RegDatos<ClaveString,Dato2Int>* nuevo4 = new RegDatos<ClaveString, Dato2Int>();
	(*nuevo4).setClave(nueva4);
	(*nuevo4).cargarDato(nDato4);
	
	int ins4 = (*a).insertarRegistro(nuevo4);
	
	cout << ins4 << endl;
	
	// INSERTAR UN NUEVO REGISTRO 5

	ClaveString* nueva5 = new ClaveString();
	(*nueva5).setClave("E");
	
	Dato2Int* nDato5 = new Dato2Int();
	(*nDato5).setDato1(25);
	(*nDato5).setDato2(10);
	
	RegDatos<ClaveString,Dato2Int>* nuevo5 = new RegDatos<ClaveString, Dato2Int>();
	(*nuevo5).setClave(nueva5);
	(*nuevo5).cargarDato(nDato5);
	
	int ins5 = (*a).insertarRegistro(nuevo5);
	
	cout << ins5 << endl;			


	delete a;		

}

void pruebaInsertarConDato2Int3(){

	ArbolBMas<ClaveString,Dato2Int>* a = new ArbolBMas<ClaveString,Dato2Int>("datoscomp.bin",100,false);

	// INSERTAR UN NUEVO REGISTRO 1

	ClaveString* nueva1 = new ClaveString();
	(*nueva1).setClave("O");
	
	Dato2Int* nDato1 = new Dato2Int();
	(*nDato1).setDato1(25);
	(*nDato1).setDato2(10);
	
	RegDatos<ClaveString,Dato2Int>* nuevo1 = new RegDatos<ClaveString, Dato2Int>();
	(*nuevo1).setClave(nueva1);
	(*nuevo1).cargarDato(nDato1);
	
	int ins1 = (*a).insertarRegistro(nuevo1);
	
	cout << ins1 << endl;

	// INSERTAR UN NUEVO REGISTRO 2

	ClaveString* nueva2 = new ClaveString();
	(*nueva2).setClave("M");
	
	Dato2Int* nDato2 = new Dato2Int();
	(*nDato2).setDato1(25);
	(*nDato2).setDato2(10);
	
	RegDatos<ClaveString,Dato2Int>* nuevo2 = new RegDatos<ClaveString, Dato2Int>();
	(*nuevo2).setClave(nueva2);
	(*nuevo2).cargarDato(nDato2);
	
	int ins2 = (*a).insertarRegistro(nuevo2);
	
	cout << ins2 << endl;
	
	// INSERTAR UN NUEVO REGISTRO 3

	ClaveString* nueva3 = new ClaveString();
	(*nueva3).setClave("L");
	
	Dato2Int* nDato3 = new Dato2Int();
	(*nDato3).setDato1(25);
	(*nDato3).setDato2(10);
	
	RegDatos<ClaveString,Dato2Int>* nuevo3 = new RegDatos<ClaveString, Dato2Int>();
	(*nuevo3).setClave(nueva3);
	(*nuevo3).cargarDato(nDato3);
	
	int ins3 = (*a).insertarRegistro(nuevo3);
	
	cout << ins3 << endl;
	
	// INSERTAR UN NUEVO REGISTRO 4

	ClaveString* nueva4 = new ClaveString();
	(*nueva4).setClave("N");
	
	Dato2Int* nDato4 = new Dato2Int();
	(*nDato4).setDato1(25);
	(*nDato4).setDato2(10);
	
	RegDatos<ClaveString,Dato2Int>* nuevo4 = new RegDatos<ClaveString, Dato2Int>();
	(*nuevo4).setClave(nueva4);
	(*nuevo4).cargarDato(nDato4);
	
	int ins4 = (*a).insertarRegistro(nuevo4);
	
	cout << ins4 << endl;
	
	// INSERTAR UN NUEVO REGISTRO 5

	ClaveString* nueva5 = new ClaveString();
	(*nueva5).setClave("P");
	
	Dato2Int* nDato5 = new Dato2Int();
	(*nDato5).setDato1(25);
	(*nDato5).setDato2(10);
	
	RegDatos<ClaveString,Dato2Int>* nuevo5 = new RegDatos<ClaveString, Dato2Int>();
	(*nuevo5).setClave(nueva5);
	(*nuevo5).cargarDato(nDato5);
	
	int ins5 = (*a).insertarRegistro(nuevo5);
	
	cout << ins5 << endl;			


	delete a;		

}

void pruebaInsertarConDato2Int4(){

	ArbolBMas<ClaveString,Dato2Int>* a = new ArbolBMas<ClaveString,Dato2Int>("datoscomp.bin",100,false);

	// INSERTAR UN NUEVO REGISTRO 1

	ClaveString* nueva1 = new ClaveString();
	(*nueva1).setClave("S");
	
	Dato2Int* nDato1 = new Dato2Int();
	(*nDato1).setDato1(25);
	(*nDato1).setDato2(10);
	
	RegDatos<ClaveString,Dato2Int>* nuevo1 = new RegDatos<ClaveString, Dato2Int>();
	(*nuevo1).setClave(nueva1);
	(*nuevo1).cargarDato(nDato1);
	
	int ins1 = (*a).insertarRegistro(nuevo1);
	
	cout << ins1 << endl;

	// INSERTAR UN NUEVO REGISTRO 2

	ClaveString* nueva2 = new ClaveString();
	(*nueva2).setClave("W");
	
	Dato2Int* nDato2 = new Dato2Int();
	(*nDato2).setDato1(25);
	(*nDato2).setDato2(10);
	
	RegDatos<ClaveString,Dato2Int>* nuevo2 = new RegDatos<ClaveString, Dato2Int>();
	(*nuevo2).setClave(nueva2);
	(*nuevo2).cargarDato(nDato2);
	
	int ins2 = (*a).insertarRegistro(nuevo2);
	
	cout << ins2 << endl;
	
	// INSERTAR UN NUEVO REGISTRO 3

	ClaveString* nueva3 = new ClaveString();
	(*nueva3).setClave("V");
	
	Dato2Int* nDato3 = new Dato2Int();
	(*nDato3).setDato1(25);
	(*nDato3).setDato2(10);
	
	RegDatos<ClaveString,Dato2Int>* nuevo3 = new RegDatos<ClaveString, Dato2Int>();
	(*nuevo3).setClave(nueva3);
	(*nuevo3).cargarDato(nDato3);
	
	int ins3 = (*a).insertarRegistro(nuevo3);
	
	cout << ins3 << endl;
	
	// INSERTAR UN NUEVO REGISTRO 4

	ClaveString* nueva4 = new ClaveString();
	(*nueva4).setClave("T");
	
	Dato2Int* nDato4 = new Dato2Int();
	(*nDato4).setDato1(25);
	(*nDato4).setDato2(10);
	
	RegDatos<ClaveString,Dato2Int>* nuevo4 = new RegDatos<ClaveString, Dato2Int>();
	(*nuevo4).setClave(nueva4);
	(*nuevo4).cargarDato(nDato4);
	
	int ins4 = (*a).insertarRegistro(nuevo4);
	
	cout << ins4 << endl;
	
	// INSERTAR UN NUEVO REGISTRO 5

	ClaveString* nueva5 = new ClaveString();
	(*nueva5).setClave("U");
	
	Dato2Int* nDato5 = new Dato2Int();
	(*nDato5).setDato1(25);
	(*nDato5).setDato2(10);
	
	RegDatos<ClaveString,Dato2Int>* nuevo5 = new RegDatos<ClaveString, Dato2Int>();
	(*nuevo5).setClave(nueva5);
	(*nuevo5).cargarDato(nDato5);
	
	int ins5 = (*a).insertarRegistro(nuevo5);
	
	cout << ins5 << endl;			


	delete a;		

}


void pruebaInsertarLuegoDeBorrar(){

	ArbolBMas<ClaveString,DatoInt>* a = new ArbolBMas<ClaveString,DatoInt>("archivo.bin",40,false);

	// INSERTAR UN NUEVO REGISTRO 1

	ClaveString* nueva1 = new ClaveString();
	(*nueva1).setClave("G");
	
	DatoInt* nDato1 = new DatoInt();
	(*nDato1).setDato(25);
	
	RegDatos<ClaveString,DatoInt>* nuevo1 = new RegDatos<ClaveString, DatoInt>();
	(*nuevo1).setClave(nueva1);
	(*nuevo1).cargarDato(nDato1);
	
	int ins1 = (*a).insertarRegistro(nuevo1);
	
	cout << ins1 << endl;

	// INSERTAR UN NUEVO REGISTRO 2

	ClaveString* nueva2 = new ClaveString();
	(*nueva2).setClave("H");
	
	DatoInt* nDato2 = new DatoInt();
	(*nDato2).setDato(25);
	
	RegDatos<ClaveString,DatoInt>* nuevo2 = new RegDatos<ClaveString, DatoInt>();
	(*nuevo2).setClave(nueva2);
	(*nuevo2).cargarDato(nDato2);
	
	int ins2 = (*a).insertarRegistro(nuevo2);
	
	cout << ins2 << endl;
	
	// INSERTAR UN NUEVO REGISTRO 3

	ClaveString* nueva3 = new ClaveString();
	(*nueva3).setClave("I");
	
	DatoInt* nDato3 = new DatoInt();
	(*nDato3).setDato(25);
	
	RegDatos<ClaveString,DatoInt>* nuevo3 = new RegDatos<ClaveString, DatoInt>();
	(*nuevo3).setClave(nueva3);
	(*nuevo3).cargarDato(nDato3);
	
	int ins3 = (*a).insertarRegistro(nuevo3);
	
	cout << ins3 << endl;
	
	// INSERTAR UN NUEVO REGISTRO 4

	ClaveString* nueva4 = new ClaveString();
	(*nueva4).setClave("J");
	
	DatoInt* nDato4 = new DatoInt();
	(*nDato4).setDato(25);
	
	RegDatos<ClaveString,DatoInt>* nuevo4 = new RegDatos<ClaveString, DatoInt>();
	(*nuevo4).setClave(nueva4);
	(*nuevo4).cargarDato(nDato4);
	
	int ins4 = (*a).insertarRegistro(nuevo4);
	
	cout << ins4 << endl;
	
	// INSERTAR UN NUEVO REGISTRO 5

	ClaveString* nueva5 = new ClaveString();
	(*nueva5).setClave("K");
	
	DatoInt* nDato5 = new DatoInt();
	(*nDato5).setDato(25);
	
	RegDatos<ClaveString,DatoInt>* nuevo5 = new RegDatos<ClaveString, DatoInt>();
	(*nuevo5).setClave(nueva5);
	(*nuevo5).cargarDato(nDato5);
	
	int ins5 = (*a).insertarRegistro(nuevo5);
	
	cout << ins5 << endl;			



	delete a;
	
}

void pruebaBorrar2(){

	ArbolBMas<ClaveString,DatoInt>* a = new ArbolBMas<ClaveString,DatoInt>("archivo.bin",40,false);
	
	ClaveString* clave1 = new ClaveString();
	(*clave1).setClave("A");
	
	ClaveString* clave2 = new ClaveString();
	(*clave2).setClave("B");
	
	ClaveString* clave3 = new ClaveString();
	(*clave3).setClave("C");
	
	ClaveString* clave4 = new ClaveString();
	(*clave4).setClave("D");

	ClaveString* clave5 = new ClaveString();
	(*clave5).setClave("E");
	
	ClaveString* clave6 = new ClaveString();
	(*clave6).setClave("F");

	ClaveString* clave7 = new ClaveString();
	(*clave7).setClave("G");
	
	ClaveString* clave8 = new ClaveString();
	(*clave8).setClave("H");

	ClaveString* clave9 = new ClaveString();
	(*clave9).setClave("I");
	
	ClaveString* clave10 = new ClaveString();
	(*clave10).setClave("J");
	
	ClaveString* clave11 = new ClaveString();
	(*clave11).setClave("K");

	ClaveString* clave12 = new ClaveString();
	(*clave12).setClave("L");
	
	ClaveString* clave13 = new ClaveString();
	(*clave13).setClave("M");	

	ClaveString* clave14 = new ClaveString();
	(*clave14).setClave("N");		

	ClaveString* clave15 = new ClaveString();
	(*clave15).setClave("O");		

	
	int b15 = (*a).borrar(clave15);					
	int b14 = (*a).borrar(clave14);	
	int b13 = (*a).borrar(clave13);				
	int b12 = (*a).borrar(clave12);				
	int b11 = (*a).borrar(clave11);				
	int b10 = (*a).borrar(clave10);				
	int b9 = (*a).borrar(clave9);		
	int b8 = (*a).borrar(clave8);		
	int b7 = (*a).borrar(clave7);		
	int b6 = (*a).borrar(clave6);	
	int b5 = (*a).borrar(clave5);
	int b4 = (*a).borrar(clave4);		
	int b3 = (*a).borrar(clave3);
	int b2 = (*a).borrar(clave2);								
	int b1 = (*a).borrar(clave1);
	
	cout << "NRO BLOQUES USADOS:\n";		

	cout << ((*((*a).getArchivo())).getNroBloquesEnUso()) << "\n" ;	
	
	cout << "\n\n";
	cout << b15 << "\n";		
	cout << b14 << "\n";	
	cout << b13 << "\n";		
	cout << b12 << "\n";		
	cout << b11 << "\n";		
	cout << b10 << "\n";			
	cout << b9 << "\n";			
	cout << b8 << "\n";		
	cout << b7 << "\n";	
	cout << b6 << "\n";					
	cout << b5 << "\n";					
	cout << b4 << "\n";						
	cout << b3 << "\n";		
	cout << b2 << "\n";					
	cout << b1 << "\n\n" << endl;				


	delete clave1;
	delete clave2;
	delete clave3;	 
	delete clave4;
	delete clave5;
	delete clave6;	 
	delete clave7;	
	delete clave8;		
	delete clave9; 
	delete clave10;				
	delete clave11;	 		
	delete clave12;			
	delete clave13;	
	delete clave14;				
	delete clave15;	
							
	delete a;

	
}	

void pruebaBorrar1(){
	
	ArbolBMas<ClaveString,DatoInt>* a = new ArbolBMas<ClaveString,DatoInt>("archivo.bin",40,false);
	
	ClaveString* clave1 = new ClaveString();
	(*clave1).setClave("A");
	
	ClaveString* clave2 = new ClaveString();
	(*clave2).setClave("B");
	
	ClaveString* clave3 = new ClaveString();
	(*clave3).setClave("C");
	
	ClaveString* clave4 = new ClaveString();
	(*clave4).setClave("D");

	ClaveString* clave5 = new ClaveString();
	(*clave5).setClave("E");
	
	ClaveString* clave6 = new ClaveString();
	(*clave6).setClave("F");

	ClaveString* clave7 = new ClaveString();
	(*clave7).setClave("G");
	
	ClaveString* clave8 = new ClaveString();
	(*clave8).setClave("H");

	ClaveString* clave9 = new ClaveString();
	(*clave9).setClave("I");
	
	ClaveString* clave10 = new ClaveString();
	(*clave10).setClave("J");
	
	ClaveString* clave11 = new ClaveString();
	(*clave11).setClave("K");

	ClaveString* clave12 = new ClaveString();
	(*clave12).setClave("L");
	
	ClaveString* clave13 = new ClaveString();
	(*clave13).setClave("M");	

	ClaveString* clave14 = new ClaveString();
	(*clave14).setClave("N");		

	ClaveString* clave15 = new ClaveString();
	(*clave15).setClave("O");		
	
	
	int b1 = (*a).borrar(clave1);
	int b2 = (*a).borrar(clave2);	
	int b3 = (*a).borrar(clave3);		
	int b4 = (*a).borrar(clave4);	
	int b5 = (*a).borrar(clave5);				
	int b6 = (*a).borrar(clave6);	
	int b7 = (*a).borrar(clave7);		
	int b8 = (*a).borrar(clave8);	
	int b9 = (*a).borrar(clave9);	
	int b10 = (*a).borrar(clave10);		
	int b11 = (*a).borrar(clave11);			
	int b12 = (*a).borrar(clave12);			
	int b13 = (*a).borrar(clave13);		
	int b14 = (*a).borrar(clave14);			
	int b15 = (*a).borrar(clave15);						
		
	
	cout << "\n\n";
	cout << b1 << "\n";
	cout << b2 << "\n";
	cout << b3 << "\n";
	cout << b4 << "\n";
	cout << b5 << "\n";
	cout << b6 << "\n";	
	cout << b7 << "\n";	
	cout << b8 << "\n";	
	cout << b9 << "\n";
	cout << b10 << "\n";					
	cout << b11 << "\n";					
	cout << b12 << "\n";					
	cout << b13 << "\n";		
	cout << b14 << "\n";					
	cout << b15 << "\n";		
	
	cout << "NRO BLOQUES USADOS:\n";		

	cout << ((*((*a).getArchivo())).getNroBloquesEnUso()) << "\n" ;

	delete clave1;
	delete clave2;
	delete clave3;	
	delete clave4;
	delete clave5;
	delete clave6;	 
	delete clave7;	
	delete clave8;		
	delete clave9;
	delete clave10;			
	delete clave11;			
	delete clave12;			
	delete clave13;	
	delete clave14;			
	delete clave15;	
							
	delete a;
	
}

void pruebaAgregarArbolRegVariables(){

	ArbolBMas<ClaveString,DatoInt>* a = new ArbolBMas<ClaveString,DatoInt>("arbol.bin",100,true);


	//// REG 1 /////
	ClaveString* clave1 = new ClaveString();	
	(*clave1).setClave("A");
	
	DatoInt* dato11 = new DatoInt();
	(*dato11).setDato(4);
	
	RegDatos<ClaveString,DatoInt>* reg1 = new RegDatos<ClaveString,DatoInt>();
	(*reg1).setClave(clave1);
	(*reg1).cargarDato(dato11);
	

	
	//// REG 2 ////
	ClaveString* clave2 = new ClaveString();	
	(*clave2).setClave("BCD");
	
	DatoInt* dato21 = new DatoInt();
	(*dato21).setDato(8);
	
	RegDatos<ClaveString,DatoInt>* reg2 = new RegDatos<ClaveString,DatoInt>();
	(*reg2).setClave(clave2);
	(*reg2).cargarDato(dato21);
	
	

	//// REG 3 ////
	ClaveString* clave3 = new ClaveString();	
	(*clave3).setClave("CE");
	
	DatoInt* dato31 = new DatoInt();
	(*dato31).setDato(10);
	
	RegDatos<ClaveString,DatoInt>* reg3 = new RegDatos<ClaveString,DatoInt>();
	(*reg3).setClave(clave3);
	(*reg3).cargarDato(dato31);
	
	
	
	//// REG 4 ////
	ClaveString* clave4 = new ClaveString();	
	(*clave4).setClave("AFCAD");
	
	DatoInt* dato41 = new DatoInt();
	(*dato41).setDato(12);
	
	RegDatos<ClaveString,DatoInt>* reg4 = new RegDatos<ClaveString,DatoInt>();
	(*reg4).setClave(clave4);
	(*reg4).cargarDato(dato41);	
	
	
	//// REG 5 ////
	ClaveString* clave5 = new ClaveString();	
	(*clave5).setClave("EDLA");
	
	DatoInt* dato51 = new DatoInt();
	(*dato51).setDato(14);
	
	RegDatos<ClaveString,DatoInt>* reg5 = new RegDatos<ClaveString,DatoInt>();
	(*reg5).setClave(clave5);
	(*reg5).cargarDato(dato51);	
	
	
	//// REG 6 ////
	ClaveString* clave6 = new ClaveString();	
	(*clave6).setClave("FHKAAF");
	
	DatoInt* dato61 = new DatoInt();
	(*dato61).setDato(16);
	
	RegDatos<ClaveString,DatoInt>* reg6 = new RegDatos<ClaveString,DatoInt>();
	(*reg6).setClave(clave6);
	(*reg6).cargarDato(dato61);	
		
	
	//// REG 7 ///
	ClaveString* clave7 = new ClaveString();	
	(*clave7).setClave("GJ");
	
	DatoInt* dato71 = new DatoInt();
	(*dato71).setDato(18);
	
	RegDatos<ClaveString,DatoInt>* reg7 = new RegDatos<ClaveString,DatoInt>();
	(*reg7).setClave(clave7);
	(*reg7).cargarDato(dato71);	
	
	
	//// REG 8 ///
	ClaveString* clave8 = new ClaveString();	
	(*clave8).setClave("H");
	
	DatoInt* dato81 = new DatoInt();
	(*dato81).setDato(20);
	
	RegDatos<ClaveString,DatoInt>* reg8 = new RegDatos<ClaveString,DatoInt>();
	(*reg8).setClave(clave8);
	(*reg8).cargarDato(dato81);	
	
	
	//// REG 9 ///
	ClaveString* clave9 = new ClaveString();	
	(*clave9).setClave("IUOUOOO");
	
	DatoInt* dato91 = new DatoInt();
	(*dato91).setDato(22);
	
	RegDatos<ClaveString,DatoInt>* reg9 = new RegDatos<ClaveString,DatoInt>();
	(*reg9).setClave(clave9);
	(*reg9).cargarDato(dato91);			
	

	//// REG 10 ///
	ClaveString* clave10 = new ClaveString();	
	(*clave10).setClave("JJLJL");
	
	DatoInt* dato101 = new DatoInt();
	(*dato101).setDato(24);
	
	RegDatos<ClaveString,DatoInt>* reg10 = new RegDatos<ClaveString,DatoInt>();
	(*reg10).setClave(clave10);
	(*reg10).cargarDato(dato101);


	
		//// REG 11 ///
	ClaveString* clave11 = new ClaveString();	
	(*clave11).setClave("K");
	
	DatoInt* dato111 = new DatoInt();
	(*dato111).setDato(26);
	
	RegDatos<ClaveString,DatoInt>* reg11 = new RegDatos<ClaveString,DatoInt>();
	(*reg11).setClave(clave11);
	(*reg11).cargarDato(dato111);		
	
	
		//// REG 12 ///
	ClaveString* clave12 = new ClaveString();	
	(*clave12).setClave("BBKAAL");
	
	DatoInt* dato121 = new DatoInt();
	(*dato121).setDato(28);
	
	RegDatos<ClaveString,DatoInt>* reg12 = new RegDatos<ClaveString,DatoInt>();
	(*reg12).setClave(clave12);
	(*reg12).cargarDato(dato121);		
	
	
	
		//// REG 13 ///
	ClaveString* clave13 = new ClaveString();	
	(*clave13).setClave("TYM");
	
	DatoInt* dato131 = new DatoInt();
	(*dato131).setDato(29);
	
	RegDatos<ClaveString,DatoInt>* reg13 = new RegDatos<ClaveString,DatoInt>();
	(*reg13).setClave(clave13);
	(*reg13).cargarDato(dato131);		
	
	
	
		//// REG 14 ///
	ClaveString* clave14 = new ClaveString();	
	(*clave14).setClave("N");
	
	DatoInt* dato141 = new DatoInt();
	(*dato141).setDato(30);
	
	RegDatos<ClaveString,DatoInt>* reg14 = new RegDatos<ClaveString,DatoInt>();
	(*reg14).setClave(clave14);
	(*reg14).cargarDato(dato141);		

	
		//// REG 15 ///
	ClaveString* clave15 = new ClaveString();	
	(*clave15).setClave("O");
	
	DatoInt* dato151 = new DatoInt();
	(*dato151).setDato(31);
	
	RegDatos<ClaveString,DatoInt>* reg15 = new RegDatos<ClaveString,DatoInt>();
	(*reg15).setClave(clave15);
	(*reg15).cargarDato(dato151);	
	
	
	 //// REG 16 ////
	ClaveString* clave16 = new ClaveString();	
	(*clave16).setClave("O");
	
	DatoInt* dato161 = new DatoInt();
	(*dato161).setDato(31);
	
	RegDatos<ClaveString,DatoInt>* reg16 = new RegDatos<ClaveString,DatoInt>();
	(*reg16).setClave(clave16);
	(*reg16).cargarDato(dato161);		 
	
	
	int ins1 = (*a).insertarRegistro(reg1);
	int ins2 = (*a).insertarRegistro(reg2);
	int ins3 = (*a).insertarRegistro(reg3);
	int ins4 = (*a).insertarRegistro(reg4);
	int ins5 = (*a).insertarRegistro(reg5);
	int ins6 = (*a).insertarRegistro(reg6);
	int ins7 = (*a).insertarRegistro(reg7);
	int ins8 = (*a).insertarRegistro(reg8);
	int ins9 = (*a).insertarRegistro(reg9);
	int ins10 = (*a).insertarRegistro(reg10);
	int ins11 = (*a).insertarRegistro(reg11);
	int ins12 = (*a).insertarRegistro(reg12);
	int ins13 = (*a).insertarRegistro(reg13);
	int ins14 = (*a).insertarRegistro(reg14);
	int ins15 = (*a).insertarRegistro(reg15);	
	int ins16 = (*a).insertarRegistro(reg16);		
	
	NodoIndice<ClaveString,DatoInt>* raiz = (NodoIndice<ClaveString,DatoInt>*)((*a).getRaiz());
	
	(*raiz).imprimir();		
	
	
	printf ("%d\n", ins1);
	printf ("%d\n", ins2);
	printf ("%d\n", ins3);
	printf ("%d\n", ins4);
	printf ("%d\n", ins5);
	printf ("%d\n", ins6);
	printf ("%d\n", ins7);
	printf ("%d\n", ins8);
	printf ("%d\n", ins9);
	printf ("%d\n", ins10);
	printf ("%d\n", ins11);
	printf ("%d\n", ins12);
	printf ("%d\n", ins13);
	printf ("%d\n", ins14);
	printf ("%d\n", ins15);		
	printf ("%d\n", ins16);			
	
	
	if (ins16 == 3) delete (reg16);
	
	
	delete (a); 	
	
	
}	

void pruebaInsertarArbol(){

	ArbolBMas<ClaveString,DatoInt>* a = new ArbolBMas<ClaveString,DatoInt>("archivo.bin",40,true);

	//// REG 1 /////
	ClaveString* clave1 = new ClaveString();	
	(*clave1).setClave("A");
	
	DatoInt* dato11 = new DatoInt();
	(*dato11).setDato(4);
	
	RegDatos<ClaveString,DatoInt>* reg1 = new RegDatos<ClaveString,DatoInt>();
	(*reg1).setClave(clave1);
	(*reg1).cargarDato(dato11);
	

	
	//// REG 2 ////
	ClaveString* clave2 = new ClaveString();	
	(*clave2).setClave("B");
	
	DatoInt* dato21 = new DatoInt();
	(*dato21).setDato(8);
	
	RegDatos<ClaveString,DatoInt>* reg2 = new RegDatos<ClaveString,DatoInt>();
	(*reg2).setClave(clave2);
	(*reg2).cargarDato(dato21);
	
	

	//// REG 3 ////
	ClaveString* clave3 = new ClaveString();	
	(*clave3).setClave("C");
	
	DatoInt* dato31 = new DatoInt();
	(*dato31).setDato(10);
	
	RegDatos<ClaveString,DatoInt>* reg3 = new RegDatos<ClaveString,DatoInt>();
	(*reg3).setClave(clave3);
	(*reg3).cargarDato(dato31);
	
	
	
	//// REG 4 ////
	ClaveString* clave4 = new ClaveString();	
	(*clave4).setClave("D");
	
	DatoInt* dato41 = new DatoInt();
	(*dato41).setDato(12);
	
	RegDatos<ClaveString,DatoInt>* reg4 = new RegDatos<ClaveString,DatoInt>();
	(*reg4).setClave(clave4);
	(*reg4).cargarDato(dato41);	
	
	
	//// REG 5 ////
	ClaveString* clave5 = new ClaveString();	
	(*clave5).setClave("E");
	
	DatoInt* dato51 = new DatoInt();
	(*dato51).setDato(14);
	
	RegDatos<ClaveString,DatoInt>* reg5 = new RegDatos<ClaveString,DatoInt>();
	(*reg5).setClave(clave5);
	(*reg5).cargarDato(dato51);	
	
	
	//// REG 6 ////
	ClaveString* clave6 = new ClaveString();	
	(*clave6).setClave("F");
	
	DatoInt* dato61 = new DatoInt();
	(*dato61).setDato(16);
	
	RegDatos<ClaveString,DatoInt>* reg6 = new RegDatos<ClaveString,DatoInt>();
	(*reg6).setClave(clave6);
	(*reg6).cargarDato(dato61);	
		
	
	//// REG 7 ///
	ClaveString* clave7 = new ClaveString();	
	(*clave7).setClave("G");
	
	DatoInt* dato71 = new DatoInt();
	(*dato71).setDato(18);
	
	RegDatos<ClaveString,DatoInt>* reg7 = new RegDatos<ClaveString,DatoInt>();
	(*reg7).setClave(clave7);
	(*reg7).cargarDato(dato71);	
	
	
	//// REG 8 ///
	ClaveString* clave8 = new ClaveString();	
	(*clave8).setClave("H");
	
	DatoInt* dato81 = new DatoInt();
	(*dato81).setDato(20);
	
	RegDatos<ClaveString,DatoInt>* reg8 = new RegDatos<ClaveString,DatoInt>();
	(*reg8).setClave(clave8);
	(*reg8).cargarDato(dato81);	
	
	
	//// REG 9 ///
	ClaveString* clave9 = new ClaveString();	
	(*clave9).setClave("I");
	
	DatoInt* dato91 = new DatoInt();
	(*dato91).setDato(22);
	
	RegDatos<ClaveString,DatoInt>* reg9 = new RegDatos<ClaveString,DatoInt>();
	(*reg9).setClave(clave9);
	(*reg9).cargarDato(dato91);			
	

	//// REG 10 ///
	ClaveString* clave10 = new ClaveString();	
	(*clave10).setClave("J");
	
	DatoInt* dato101 = new DatoInt();
	(*dato101).setDato(24);
	
	RegDatos<ClaveString,DatoInt>* reg10 = new RegDatos<ClaveString,DatoInt>();
	(*reg10).setClave(clave10);
	(*reg10).cargarDato(dato101);


	
		//// REG 11 ///
	ClaveString* clave11 = new ClaveString();	
	(*clave11).setClave("K");
	
	DatoInt* dato111 = new DatoInt();
	(*dato111).setDato(26);
	
	RegDatos<ClaveString,DatoInt>* reg11 = new RegDatos<ClaveString,DatoInt>();
	(*reg11).setClave(clave11);
	(*reg11).cargarDato(dato111);		
	
	
		//// REG 12 ///
	ClaveString* clave12 = new ClaveString();	
	(*clave12).setClave("L");
	
	DatoInt* dato121 = new DatoInt();
	(*dato121).setDato(28);
	
	RegDatos<ClaveString,DatoInt>* reg12 = new RegDatos<ClaveString,DatoInt>();
	(*reg12).setClave(clave12);
	(*reg12).cargarDato(dato121);		
	
	
	
		//// REG 13 ///
	ClaveString* clave13 = new ClaveString();	
	(*clave13).setClave("M");
	
	DatoInt* dato131 = new DatoInt();
	(*dato131).setDato(29);
	
	RegDatos<ClaveString,DatoInt>* reg13 = new RegDatos<ClaveString,DatoInt>();
	(*reg13).setClave(clave13);
	(*reg13).cargarDato(dato131);		
	
	
	
		//// REG 14 ///
	ClaveString* clave14 = new ClaveString();	
	(*clave14).setClave("N");
	
	DatoInt* dato141 = new DatoInt();
	(*dato141).setDato(30);
	
	RegDatos<ClaveString,DatoInt>* reg14 = new RegDatos<ClaveString,DatoInt>();
	(*reg14).setClave(clave14);
	(*reg14).cargarDato(dato141);		

	
		//// REG 15 ///
	ClaveString* clave15 = new ClaveString();	
	(*clave15).setClave("O");
	
	DatoInt* dato151 = new DatoInt();
	(*dato151).setDato(31);
	
	RegDatos<ClaveString,DatoInt>* reg15 = new RegDatos<ClaveString,DatoInt>();
	(*reg15).setClave(clave15);
	(*reg15).cargarDato(dato151);	
	
	
	int ins1 = (*a).insertarRegistro(reg1);
	
////////////	
	ClaveString* clave_1 = new ClaveString();
	(*clave_1).setClave("A"); 
	
	RegDatos<ClaveString,DatoInt>* reg_1 = (*a).buscar(clave_1);
	
	cout << (*((*reg_1).getClave())) << endl;
//////////	
	
	int ins2 = (*a).insertarRegistro(reg2);
	
////////////	
	ClaveString* clave_2 = new ClaveString();
	(*clave_2).setClave("B"); 
	
	RegDatos<ClaveString,DatoInt>* reg_2 = (*a).buscar(clave_2);
	
	cout << (*((*reg_2).getClave())) << endl;
//////////
	
	int ins3 = (*a).insertarRegistro(reg3);
	
////////////	
	ClaveString* clave_3 = new ClaveString();
	(*clave_3).setClave("C"); 
	
	RegDatos<ClaveString,DatoInt>* reg_3 = (*a).buscar(clave_3);
	
	cout << (*((*reg_3).getClave())) << endl;
//////////	
	
	int ins4 = (*a).insertarRegistro(reg4);
////////////	
	ClaveString* clave_4 = new ClaveString();
	(*clave_4).setClave("D"); 
	
	RegDatos<ClaveString,DatoInt>* reg_4 = (*a).buscar(clave_4);
	
	cout << (*((*reg_4).getClave())) << endl;
//////////
		
	int ins5 = (*a).insertarRegistro(reg5);
	
////////////	
	ClaveString* clave_5 = new ClaveString();
	(*clave_5).setClave("E"); 
	
	RegDatos<ClaveString,DatoInt>* reg_5 = (*a).buscar(clave_5);
	
	cout << (*((*reg_5).getClave())) << endl;
//////////	
	
	int ins6 = (*a).insertarRegistro(reg6);
	int ins7 = (*a).insertarRegistro(reg7);
	int ins8 = (*a).insertarRegistro(reg8);
	int ins9 = (*a).insertarRegistro(reg9);
	int ins10 = (*a).insertarRegistro(reg10);
	int ins11 = (*a).insertarRegistro(reg11);
	int ins12 = (*a).insertarRegistro(reg12);
	int ins13 = (*a).insertarRegistro(reg13);
	int ins14 = (*a).insertarRegistro(reg14);
	int ins15 = (*a).insertarRegistro(reg15);	
	
	printf ("%d\n", ins1);
	printf ("%d\n", ins2);
	printf ("%d\n", ins3);
	printf ("%d\n", ins4);
	printf ("%d\n", ins5);
	printf ("%d\n", ins6);
	printf ("%d\n", ins7);
	printf ("%d\n", ins8);
	printf ("%d\n", ins9);
	printf ("%d\n", ins10);
	printf ("%d\n", ins11);
	printf ("%d\n", ins12);
	printf ("%d\n", ins13);
	printf ("%d\n", ins14);
	printf ("%d\n", ins15);		
	

	NodoIndice<ClaveString,DatoInt>* seis = new NodoIndice<ClaveString,DatoInt>();
	NodoIndice<ClaveString,DatoInt>* siete = new NodoIndice<ClaveString,DatoInt>();
	NodoIndice<ClaveString,DatoInt>* once = new NodoIndice<ClaveString,DatoInt>();
	NodoDatos<ClaveString,DatoInt>* uno = new NodoDatos<ClaveString,DatoInt>();
	NodoDatos<ClaveString,DatoInt>* dos = new NodoDatos<ClaveString,DatoInt>();
	NodoDatos<ClaveString,DatoInt>* tres = new NodoDatos<ClaveString,DatoInt>();
	NodoDatos<ClaveString,DatoInt>* cuatro = new NodoDatos<ClaveString,DatoInt>();
	NodoDatos<ClaveString,DatoInt>* cinco = new NodoDatos<ClaveString,DatoInt>();
	NodoDatos<ClaveString,DatoInt>* ocho = new NodoDatos<ClaveString,DatoInt>();
	NodoDatos<ClaveString,DatoInt>* nueve = new NodoDatos<ClaveString,DatoInt>();
	NodoDatos<ClaveString,DatoInt>* diez = new NodoDatos<ClaveString,DatoInt>();
	
	ArchivoBloques<ClaveString,DatoInt>* arch = (*a).getArchivo();
	
	(*arch).leerBloque(seis, 6);
	(*arch).leerBloque(siete, 7);
	(*arch).leerBloque(once, 11);
	(*arch).leerBloque(uno, 1);
	(*arch).leerBloque(dos, 2);
	(*arch).leerBloque(tres, 3);
	(*arch).leerBloque(cuatro, 4);
	(*arch).leerBloque(cinco, 5);
	(*arch).leerBloque(ocho, 8);
	(*arch).leerBloque(nueve, 9);
	(*arch).leerBloque(diez, 10);


	NodoIndice<ClaveString,DatoInt>* raiz = (NodoIndice<ClaveString,DatoInt>*)((*a).getRaiz());
	
	(*raiz).imprimir();		
	
	(*seis).imprimir();				
	(*siete).imprimir();
	(*once).imprimir();
	(*uno).imprimir();
	(*dos).imprimir();
	(*tres).imprimir();
	(*cuatro).imprimir();
	(*cinco).imprimir();	
	(*ocho).imprimir();	
	(*nueve).imprimir();
	(*diez).imprimir();		
						
	
	/*
							0 : (6) G (7) M (11)
							
			
		6: (1) C (2) E		7: (4) I (5) K (8)			11: (9) O (10)
		
	
	1: AB	2: CD	3: EF	4: GH	5: IJ	8: KL		9: MN		10: O
	*/
	
	delete clave_1;
	delete clave_2;
	delete clave_3;
	delete clave_4;
	delete clave_5;
	
	delete reg_1;
	delete reg_2;
	delete reg_3;
	delete reg_4;
	delete reg_5;
	
	delete seis;
	delete siete;
	delete once;
	delete uno;
	delete dos;
	delete tres;
	delete cuatro;
	delete cinco;
	delete ocho;
	delete nueve;
	delete diez;

	delete (a); 	

}

void pruebaInsertarEnArbolCreado(){
	ArbolBMas<ClaveString,DatoInt>* a = new ArbolBMas<ClaveString,DatoInt>("archivo.bin",40,false);
	
	
	//// REGISTRO /////
	ClaveString* clave = new ClaveString();	
	(*clave).setClave("P");
/*	
	DatoInt* dato = new DatoInt();
	(*dato).setDato(33);
*/	
	RegDatos<ClaveString,DatoInt>* reg = new RegDatos<ClaveString,DatoInt>();
	(*reg).setClave(clave);
//	(*reg).cargarDato(dato);
	
	(*a).insertarRegistro(reg);
	
	/*
							0 : (6) G (7) M (11)
							
			
		6: (1) C (2) E		7: (4) I (5) K (8)			11: (9) O (10)
		
	
	1: AB	2: CD	3: EF	4: GH	5: IJ	8: KL		9: MN		10: OP  <--- insercion
	*/	
	
	
	
	delete a;
	
	
	
}

void pruebaLeerArbolCreado(){ // FUNCIONA SI SE LLAMA LUEGO DE PRUEBAINSERTARARBOL
								// Y PRUEBAINSERTARENARBOLCREADO

	ArbolBMas<ClaveString,DatoInt>* a = new ArbolBMas<ClaveString,DatoInt>("archivo.bin",40,false);
	
	NodoIndice<ClaveString,DatoInt>* seis = new NodoIndice<ClaveString,DatoInt>();
	NodoIndice<ClaveString,DatoInt>* siete = new NodoIndice<ClaveString,DatoInt>();
	NodoIndice<ClaveString,DatoInt>* once = new NodoIndice<ClaveString,DatoInt>();
	NodoDatos<ClaveString,DatoInt>* uno = new NodoDatos<ClaveString,DatoInt>();
	NodoDatos<ClaveString,DatoInt>* dos = new NodoDatos<ClaveString,DatoInt>();
	NodoDatos<ClaveString,DatoInt>* tres = new NodoDatos<ClaveString,DatoInt>();
	NodoDatos<ClaveString,DatoInt>* cuatro = new NodoDatos<ClaveString,DatoInt>();
	NodoDatos<ClaveString,DatoInt>* cinco = new NodoDatos<ClaveString,DatoInt>();
	NodoDatos<ClaveString,DatoInt>* ocho = new NodoDatos<ClaveString,DatoInt>();
	NodoDatos<ClaveString,DatoInt>* nueve = new NodoDatos<ClaveString,DatoInt>();
	NodoDatos<ClaveString,DatoInt>* diez = new NodoDatos<ClaveString,DatoInt>();
	
	ArchivoBloques<ClaveString,DatoInt>* arch = (*a).getArchivo();
	
	(*arch).leerBloque(seis, 6);
	(*arch).leerBloque(siete, 7);
	(*arch).leerBloque(once, 11);
	(*arch).leerBloque(uno, 1);
	(*arch).leerBloque(dos, 2);
	(*arch).leerBloque(tres, 3);
	(*arch).leerBloque(cuatro, 4);
	(*arch).leerBloque(cinco, 5);
	(*arch).leerBloque(ocho, 8);
	(*arch).leerBloque(nueve, 9);
	(*arch).leerBloque(diez, 10);
	

	NodoIndice<ClaveString,DatoInt>* raiz = (NodoIndice<ClaveString,DatoInt>*)((*a).getRaiz());
	
	(*raiz).imprimir();		
	
	(*seis).imprimir();				
	(*siete).imprimir();
	(*once).imprimir();
	(*uno).imprimir();
	(*dos).imprimir();
	(*tres).imprimir();
	(*cuatro).imprimir();
	(*cinco).imprimir();	
	(*ocho).imprimir();	
	(*nueve).imprimir();
	(*diez).imprimir();		


	/*
							0 : (6) G (7) M (11)
							
			
		6: (1) C (2) E		7: (4) I (5) K (8)			11: (9) O (10)
		
	
	1: AB	2: CD	3: EF	4: GH	5: IJ	8: KL		9: MN		10: OP
	*/
	
	
	delete seis;
	delete siete;
	delete once;
	delete uno;
	delete dos;
	delete tres;
	delete cuatro;
	delete cinco;
	delete ocho;
	delete nueve;
	delete diez;

	delete (a); 
	
	
}


void pruebaBuscar(){

		ArbolBMas<ClaveString,DatoInt>* a = new ArbolBMas<ClaveString,DatoInt>("archivo.bin",40,false);
		
		ClaveString* clave = new ClaveString();
		(*clave).setClave("BC");


		ClaveString* clave2 = new ClaveString();
		(*clave2).setClave("E");
	
		RegDatos<ClaveString,DatoInt>* reg = (*a).buscar(clave);
		
		RegDatos<ClaveString,DatoInt>* reg2 = (*a).buscar(clave2);
	
		NodoDatos<ClaveString,DatoInt>* usec = (*a).getUltimoSecuencia();
		
		cout << *((*reg).getClave()) << "\n";
		cout << *((*reg2).getClave()) << "\n";
		cout << *((*((*usec).getPrimerRegistro())).getClave()) << "\n";
	
		if (reg != NULL){		
			delete reg;
		}
		
		if (reg2 != NULL){		
			delete reg2;
		}
		
		delete a;
		delete clave;
		delete clave2;
}


void pruebaAgregarDato(){
		
	ArbolBMas<ClaveString,DatoInt>* a = new ArbolBMas<ClaveString,DatoInt>("archivo.bin",40,false);

	cout << "\nTest agregar Dato: ";	

	DatoInt* nuevoDato = new DatoInt();	
	nuevoDato->setDato(40);
	
	ClaveString* claveRecup = new ClaveString();
	claveRecup->setClave("P");
	imprimirSelectivo("\ncreo dato y clave: ", (nuevoDato->getDato() == 40) && sonIguales(claveRecup->getClave(),"P") );

	int ins = a->modificarRegistro(claveRecup, nuevoDato);
	imprimirSelectivo("\ncambio el reg con esa clave en el arbol: ", (ins==0) );
	
	if(ins == 5){ 			// Si la clave no estaba en el arbol no se pudo hacer nada y
		delete nuevoDato;	// hay que liberar el dato	
	}

	delete a;
	delete claveRecup;
}


void pruebaClave3Int(){
	
	cout << "\nTest Clave3Int: ";

	Clave3Int c1;
	c1.setClave1(2);
	c1.setClave2(1);
	c1.setClave3(3);

	Clave3Int c2;
	c2.setClave1(2);
	c2.setClave2(5);
	c2.setClave3(9);	

	Clave3Int c3;
	c3.setClave1(7);
	c3.setClave2(1);
	c3.setClave3(6);

	Clave3Int c4;
	c4.setClave1(7);
	c4.setClave2(1);
	c4.setClave3(7);	

	Clave3Int c5;
	c5.setClave1(7);
	c5.setClave2(1);
	c5.setClave3(7);

	bool c1Ok = (c1.getClave1() == 2) && (c1.getClave2() == 1) && (c1.getClave3() == 3); 
	bool c2Ok = (c2.getClave1() == 2) && (c2.getClave2() == 5) && (c2.getClave3() == 9); 
	bool c3Ok = (c3.getClave1() == 7) && (c3.getClave2() == 1) && (c3.getClave3() == 6); 
	bool c4Ok = (c4.getClave1() == 7) && (c4.getClave2() == 1) && (c4.getClave3() == 7); 
	bool c5Ok = (c5.getClave1() == 7) && (c5.getClave2() == 1) && (c5.getClave3() == 7); 

	imprimirSelectivo("\nTest crear Clave3Int: \t\t",(c1Ok && c2Ok && c3Ok && c4Ok && c5Ok));
	
	imprimirSelectivo("\nTest operador < sobrecargado: \t",   (c1<c2)  &&  (c1<c3) &&   (c3<c4) &&  (!(c4<c5)));
	imprimirSelectivo("\nTest operador > sobrecargado: \t",   (c2>c1)  &&  (c3>c1) &&   (c4>c3) &&  (!(c5>c4)));
	imprimirSelectivo("\nTest operador == sobrecargado: \t", !(c2==c1) && !(c3==c1) && !(c4==c3) && ( (c5==c4)));
	cout << "\n";
}
